todo/repositories/abstract_repository.py (1)

184-201: AbstractAuditLogRepository interface mismatches PostgresAuditLog fields

The concrete Postgres implementation in todo/repositories/postgres_repository.py invokes filters on fields that don’t exist on the PostgresAuditLog model:

• get_by_user(...) filters on user_mongo_id, but the Django model defines performed_by instead.
• get_by_collection(...) filters on collection_name, yet no such column exists on PostgresAuditLog.

As-is, these calls will raise runtime errors. To resolve:

• Rename and adjust get_by_user to get_by_performed_by (and filter on performed_by).
• Either remove or redefine get_by_collection to target a valid field (e.g. task_id or team_id), or update the model to include the intended column.
• Update the abstract interface (AbstractAuditLogRepository) to match the revised method names and signatures.

Please make these critical fixes before merging.

todo/services/task_assignment_service.py (1)

63-73: Guard against creation failures; exclusivity is already enforced

• After calling TaskAssignmentRepository.create(...), add a check to surface failures instead of returning a response with missing identifiers:

   assignment = TaskAssignmentRepository.create(task_assignment)
   if not assignment:
       raise ValueError("Failed to create task assignment")

• The repository’s update_assignment method (in todo/repositories/task_assignment_repository.py, lines 90–109) already deactivates any existing active assignments—first by matching on ObjectId(task_id), then on the string task_id—before creating the new assignment, ensuring that a task cannot remain assigned to both a team and an individual simultaneously.

todo/repositories/team_creation_invite_code_repository.py (2)

31-35: Critical: find_one_and_update returns the pre-update doc due to wrong return_document value

PyMongo expects ReturnDocument.BEFORE/AFTER, not a boolean. Passing True will not yield the updated document and will likely return the pre-update version, breaking the dual-write payload and the method’s return value.

Apply this diff:

-            result = collection.find_one_and_update(
+            result = collection.find_one_and_update(
                 {"code": code, "is_used": False},
-                {"$set": {"is_used": True, "used_by": used_by, "used_at": current_time.isoformat()}},
-                return_document=True,
+                {"$set": {"is_used": True, "used_by": used_by, "used_at": current_time}},
+                return_document=ReturnDocument.AFTER,
             )

And add the missing import at the top of the file:

+from pymongo import ReturnDocument

---

122-131: Consistent API shape for created_by/used_by in list response

created_by falls back to {}, while used_by is None when unavailable. This asymmetry complicates clients. Recommend returning None for both when absent.

-                enhanced_code = {
+                enhanced_code = {
                     "id": str(code["_id"]),
                     "code": code["code"],
                     "description": code.get("description"),
                     "created_at": code.get("created_at"),
                     "used_at": code.get("used_at"),
                     "is_used": code.get("is_used", False),
-                    "created_by": created_by_user or {},
-                    "used_by": used_by_user,
+                    "created_by": created_by_user or None,
+                    "used_by": used_by_user or None,
                 }

todo/repositories/team_repository.py (3)

80-106: Missing Postgres dual-write on team update

The create path dual-writes, but update doesn’t. Postgres will drift from Mongo. Add an update_document call after a successful Mongo update.

         updated_doc = teams_collection.find_one_and_update(
             {"_id": ObjectId(team_id), "is_deleted": False},
             {"$set": update_data},
             return_document=ReturnDocument.AFTER,
         )
 
-        if updated_doc:
-            return TeamModel(**updated_doc)
+        if updated_doc:
+            # Sync update to Postgres
+            dual_write_service = EnhancedDualWriteService()
+            team_data = {
+                "name": updated_doc.get("name"),
+                "description": updated_doc.get("description"),
+                "invite_code": updated_doc.get("invite_code"),
+                "poc_id": str(updated_doc.get("poc_id")) if updated_doc.get("poc_id") else None,
+                "created_by": str(updated_doc.get("created_by")),
+                "updated_by": str(updated_doc.get("updated_by")),
+                "is_deleted": updated_doc.get("is_deleted", False),
+                "created_at": updated_doc.get("created_at"),
+                "updated_at": updated_doc.get("updated_at"),
+            }
+            dual_write_success = dual_write_service.update_document(
+                collection_name="teams", mongo_id=str(updated_doc["_id"]), data=team_data
+            )
+            if not dual_write_success:
+                logger.warning(f"Failed to sync team update {updated_doc['_id']} to Postgres")
+            return TeamModel(**updated_doc)

Ensure a module-level logger is available (see separate comment).

---

332-347: Reactivation path returns stale data and skips Postgres sync

When reactivating an existing relationship, you update Mongo but return the pre-update document and don’t sync Postgres. Use find_one_and_update with ReturnDocument.AFTER and call update_document.

-            if not existing_relationship.get("is_active", True):
-                collection.update_one(
-                    {"_id": existing_relationship["_id"]},
-                    {
-                        "$set": {
-                            "is_active": True,
-                            "role_id": role_id,
-                            "updated_by": created_by_user_id,
-                            "updated_at": datetime.now(timezone.utc),
-                        }
-                    },
-                )
-                return UserTeamDetailsModel(**existing_relationship)
+            if not existing_relationship.get("is_active", True):
+                updated = collection.find_one_and_update(
+                    {"_id": existing_relationship["_id"]},
+                    {
+                        "$set": {
+                            "is_active": True,
+                            "role_id": role_id,
+                            "updated_by": created_by_user_id,
+                            "updated_at": datetime.now(timezone.utc),
+                        }
+                    },
+                    return_document=ReturnDocument.AFTER,
+                )
+                if updated:
+                    dual_write_service = EnhancedDualWriteService()
+                    payload = {
+                        "user_id": str(updated["user_id"]),
+                        "team_id": str(updated["team_id"]),
+                        "is_active": True,
+                        "created_by": str(updated["created_by"]),
+                        "updated_by": str(updated["updated_by"]),
+                        "created_at": updated["created_at"],
+                        "updated_at": updated["updated_at"],
+                    }
+                    if not dual_write_service.update_document(
+                        collection_name="user_team_details", mongo_id=str(updated["_id"]), data=payload
+                    ):
+                        logger.warning(f"Failed to sync user team reactivation {updated['_id']} to Postgres")
+                    return UserTeamDetailsModel(**updated)
+                return UserTeamDetailsModel(**existing_relationship)

---

280-296: Optional: collapse read-then-update into a single atomic operation

You read the active relationship, then update it. This is two round trips and susceptible to races. Consider find_one_and_update with ReturnDocument.BEFORE/AFTER to both assert is_active and get the prior doc in one call (you already did this pattern elsewhere).

If you want, I can draft a patch to switch remove_user_from_team to a single atomic call with the same dual-write behavior.

todo/repositories/watchlist_repository.py (3)

28-36: Normalize ID string conversions for model initialization

You convert updatedBy to str when present, but not createdBy. Be consistent to avoid Pydantic coercion surprises.

         if doc:
             # Convert ObjectId fields to strings for the model
-            if "updatedBy" in doc and doc["updatedBy"]:
+            if "updatedBy" in doc and doc["updatedBy"]:
                 doc["updatedBy"] = str(doc["updatedBy"])
+            if "createdBy" in doc and doc["createdBy"]:
+                doc["createdBy"] = str(doc["createdBy"])
             return WatchlistModel(**doc)

---

317-325: Inconsistent type for updatedBy: store as str for consistency

Elsewhere IDs are stored as strings in watchlists. Here you’re writing an ObjectId. Standardize on strings to match queries and pipelines that rely on $toObjectId later.

         update_result = watchlist_collection.update_one(
             {"userId": str(userId), "taskId": str(taskId)},
             {
                 "$set": {
                     "isActive": isActive,
                     "updatedAt": datetime.now(timezone.utc),
-                    "updatedBy": userId,
+                    "updatedBy": str(userId),
                 }
             },
         )

---

307-353: Refactor update() return annotation in watchlist_repository.py

The update method is currently declared as returning a dict but actually returns a pymongo.results.UpdateResult or None. Please adjust the signature and imports as follows:

• File: todo/repositories/watchlist_repository.py
• Location: method definition on line ~307

Suggested diff:

-from datetime import datetime, timezone
-from typing import List, Tuple
-from typing import Optional
+from datetime import datetime, timezone
+from typing import List, Tuple, Optional
+from pymongo.results import UpdateResult

 class WatchlistRepository(MongoRepository):
@@
-    @classmethod
-    def update(cls, taskId: ObjectId, isActive: bool, userId: ObjectId) -> dict:
+    @classmethod
+    def update(cls, taskId: ObjectId, isActive: bool, userId: ObjectId) -> Optional[UpdateResult]:
         """
         Update the watchlist status of a task.
         """

• Import UpdateResult from pymongo.results so the annotation resolves at runtime.
• Use Optional[UpdateResult] to accurately reflect that the method may return None.

todo/repositories/task_repository.py (1)

269-293: Soft-delete is not dual-written; Postgres gets out of sync.

delete_by_id marks isDeleted=True in Mongo but never syncs to Postgres. Add a dual-write update to keep Postgres consistent.

         deleted_task_data = tasks_collection.find_one_and_update(
             {"_id": task_id},
             {
                 "$set": {
                     "isDeleted": True,
                     "updatedAt": datetime.now(timezone.utc),
                     "updatedBy": user_id,
                 }
             },
             return_document=ReturnDocument.AFTER,
         )
 
-        if deleted_task_data:
-            return TaskModel(**deleted_task_data)
+        if deleted_task_data:
+            # Dual-write soft delete to Postgres
+            try:
+                dual_write_service = EnhancedDualWriteService()
+                dw_payload = {
+                    "isDeleted": True,
+                    "updatedAt": deleted_task_data["updatedAt"],
+                    "updatedBy": str(user_id),
+                }
+                dual_write_service.update_document(
+                    collection_name="tasks",
+                    mongo_id=str(task_id),
+                    data=dw_payload,
+                )
+            except Exception:
+                # Best-effort: do not block Mongo success
+                import logging
+                logging.getLogger(__name__).warning(f"Failed to sync task soft-delete {task_id} to Postgres")
+            return TaskModel(**deleted_task_data)
         return None

todo/repositories/task_assignment_repository.py (2)

158-166: Potential crash: PyObjectId(None) for team_id when user_type != "team".

Constructing PyObjectId with None will raise. Guard the conversion.

             new_assignment = TaskAssignmentModel(
                 _id=PyObjectId(),
                 task_id=PyObjectId(task_id),
                 assignee_id=PyObjectId(assignee_id),
                 user_type=user_type,
                 created_by=PyObjectId(user_id),
                 updated_by=None,
-                team_id=PyObjectId(team_id),
+                team_id=PyObjectId(team_id) if team_id else None,
             )

---

243-266: Type drift: storing assignee_id/updated_by as strings; use ObjectId consistently.

Mixed types in Mongo will break queries and necessitate fallbacks. Keep ObjectId for both update paths.

             result = collection.update_one(
                 {"task_id": ObjectId(task_id), "is_active": True},
                 {
                     "$set": {
-                        "assignee_id": executor_id,
+                        "assignee_id": ObjectId(executor_id),
                         "user_type": "user",
-                        "updated_by": user_id,
+                        "updated_by": ObjectId(user_id),
                         "updated_at": datetime.now(timezone.utc),
                     }
                 },
             )
             if result.modified_count == 0:
                 # Try with string if ObjectId doesn't work
                 result = collection.update_one(
                     {"task_id": task_id, "is_active": True},
                     {
                         "$set": {
-                            "assignee_id": executor_id,
+                            "assignee_id": ObjectId(executor_id),
                             "user_type": "user",
-                            "updated_by": user_id,
+                            "updated_by": ObjectId(user_id),
                             "updated_at": datetime.now(timezone.utc),
                         }
                     },
                 )

docker-compose.yml (1)

93-95: Connect mongo-express to the replica set

The Mongo container runs with --replSet rs0. Point mongo-express at the replica set URI for correctness.

Apply this diff:

-      ME_CONFIG_MONGODB_URL: mongodb://db:27017/
+      ME_CONFIG_MONGODB_URL: mongodb://db:27017/?replicaSet=rs0

todo_project/settings/base.py (1)

239-239: Safe default for CORS_ALLOWED_ORIGINS

Accessing os.getenv("CORS_ALLOWED_ORIGINS").split(",") will raise when the env var is unset. Provide a safe default.

Apply this diff:

-CORS_ALLOWED_ORIGINS = os.getenv("CORS_ALLOWED_ORIGINS").split(",")
+_cors = os.getenv("CORS_ALLOWED_ORIGINS", "")
+CORS_ALLOWED_ORIGINS = [o for o in _cors.split(",") if o] if _cors else []

todo/services/task_assignment_service.py (5)

46-53: Make audit “unassign” logging best-effort (don’t fail the main flow) and de-risk typos

Recommendation:

• Wrap audit log writes in try/except so logging failures don’t break assignment updates.
• Centralize action names as constants or an Enum to avoid string typos.

-            if existing_assignment.user_type == "team":
-                AuditLogRepository.create(
-                    AuditLogModel(
-                        task_id=existing_assignment.task_id,
-                        team_id=existing_assignment.assignee_id,
-                        action="unassigned_from_team",
-                        performed_by=PyObjectId(user_id),
-                    )
-                )
+            if existing_assignment.user_type == "team":
+                try:
+                    AuditLogRepository.create(
+                        AuditLogModel(
+                            task_id=existing_assignment.task_id,
+                            team_id=existing_assignment.assignee_id,
+                            action="unassigned_from_team",  # TODO: replace with AuditAction.UNASSIGNED_FROM_TEAM
+                            performed_by=PyObjectId(user_id),
+                        )
+                    )
+                except Exception:
+                    # TODO: replace with project logger
+                    # logger.exception("Failed to write audit log for team unassignment")
+                    pass

---

75-83: Apply the same best-effort pattern to “assigned_to_team” logging and consider action constants

Mirror the try/except used for unassign logs and avoid raw string actions.

-        if assignment.user_type == "team":
-            AuditLogRepository.create(
-                AuditLogModel(
-                    task_id=assignment.task_id,
-                    team_id=assignment.assignee_id,
-                    action="assigned_to_team",
-                    performed_by=PyObjectId(user_id),
-                )
-            )
+        if assignment.user_type == "team":
+            try:
+                AuditLogRepository.create(
+                    AuditLogModel(
+                        task_id=assignment.task_id,
+                        team_id=assignment.assignee_id,
+                        action="assigned_to_team",  # TODO: replace with AuditAction.ASSIGNED_TO_TEAM
+                        performed_by=PyObjectId(user_id),
+                    )
+                )
+            except Exception:
+                # logger.exception("Failed to write audit log for team assignment")
+                pass

---

85-97: Remove or track the commented “legacy” block

Commented code risks rot. Either:

• Remove it, or
• Add a TODO with an issue reference/owner, or
• Hide behind a feature flag if it must linger.

---

41-60: Ensure TaskAssignment dual-write enforces single active assignment and atomic consistency

The current implementation in TaskAssignmentRepository.update_assignment does not appear to:

• Deactivate any prior active assignments for that task in Mongo (is_active = false) before marking the new one active.
• Mirror that deactivation in Postgres (and the subsequent new assignment insert/update) within the same logical operation.
• Enforce via a database constraint that only one “active” assignment per task can exist in Postgres.

Mandatory fixes:

• In TaskAssignmentRepository.update_assignment (around todo/repositories/task_assignment_repository.py:90–120), add an explicit deactivation step that sets is_active = False on all existing assignments for the given task_id in Mongo, then create/update the new assignment record (and use the dual-write service to sync both the deactivation and the new activation to Postgres).
• In your Django migrations (e.g. todo/migrations/0001_initial_setup.py), add a partial unique index on postgres_task_assignments over (task_mongo_id) where is_active = true, or a unique_together + CheckConstraint equivalent, to enforce “one active assignment per task” at the database level.
• Introduce idempotency support on your dual-write paths (e.g. outbox table entries or idempotency keys in EnhancedDualWriteService) so that retries don’t create duplicate or conflicting records.
• Document the write ordering and failure-recovery strategy in docs/DUAL_WRITE_SYSTEM.md (e.g., “Mongo deactivation → PG deactivation → Mongo creation → PG creation with transaction boundaries, backed by an outbox that retries on failure”).

---

35-39: Add and map TeamNotFoundException for consistent 404 handling

The codebase currently lacks a TeamNotFoundException and a corresponding API error message, so replacing the ValueError won’t work until we introduce and wire up a new exception type. Please:

• Create the exception

  + todo/exceptions/team_exceptions.py
  +-------------------------------
  + from todo.constants.messages import ApiErrors
  +
  + class TeamNotFoundException(Exception):
  +     def __init__(self, team_id: str | None = None, message_template: str = ApiErrors.TEAM_NOT_FOUND):
  +         if team_id:
  +             message = message_template.format(team_id)
  +         else:
  +             message = message_template
  +         super().__init__(message)

• Add the “team not found” API error constant

   todo/constants/messages.py
   ---------------------------
   class ApiErrors:
       USER_NOT_FOUND = "User not found: {}"
       TASK_NOT_FOUND = "Task not found: {}"
  +    TEAM_NOT_FOUND = "Team not found: {}"

• Wire it into the global exception handler

   todo/exceptions/exception_handler.py
   ------------------------------------
       elif isinstance(exc, TaskNotFoundException):
           status_code = status.HTTP_404_NOT_FOUND
           error_list.append(ApiErrorDetail(detail=str(exc)))
  +    elif isinstance(exc, TeamNotFoundException):
  +        status_code = status.HTTP_404_NOT_FOUND
  +        error_list.append(ApiErrorDetail(detail=str(exc)))

• Update the service to raise the new exception

   todo/services/task_assignment_service.py
   ----------------------------------------
       elif dto.user_type == "team":
           assignee = TeamRepository.get_by_id(dto.assignee_id)
           if not assignee:
  -             raise ValueError(f"Team not found: {dto.assignee_id}")
  +             raise TeamNotFoundException(dto.assignee_id)

• Don’t forget to add:

  from todo.exceptions.team_exceptions import TeamNotFoundException

These changes will ensure missing‐team errors use a domain‐specific exception and return HTTP 404 in line with users/tasks.

todo/repositories/team_creation_invite_code_repository.py (2)

31-35: Bug: return_document must be ReturnDocument.AFTER, not True

PyMongo requires the ReturnDocument enum; passing True will raise a TypeError at runtime.

+from pymongo.collection import ReturnDocument
@@
-            result = collection.find_one_and_update(
+            result = collection.find_one_and_update(
                 {"code": code, "is_used": False},
-                {"$set": {"is_used": True, "used_by": used_by, "used_at": current_time.isoformat()}},
-                return_document=True,
+                {"$set": {"is_used": True, "used_by": used_by, "used_at": current_time}},
+                return_document=ReturnDocument.AFTER,
             )

---

31-35: Ensure used_by is stored as ObjectId in Mongo; normalize created_at for dual-write

Keep Mongo types consistent (ObjectId) and send normalized datetimes to Postgres to avoid serialization errors.

 from datetime import datetime, timezone
+from bson import ObjectId
@@
-            result = collection.find_one_and_update(
+            # normalize used_by to ObjectId where possible
+            try:
+                used_by_value = ObjectId(used_by) if used_by else None
+            except Exception:
+                used_by_value = used_by  # fallback to existing behavior
+            result = collection.find_one_and_update(
                 {"code": code, "is_used": False},
-                {"$set": {"is_used": True, "used_by": used_by, "used_at": current_time}},
+                {"$set": {"is_used": True, "used_by": used_by_value, "used_at": current_time}},
                 return_document=ReturnDocument.AFTER,
             )
@@
-                invite_code_data = {
+                # normalize created_at (legacy records may be strings)
+                _created_at = result.get("created_at")
+                if isinstance(_created_at, str):
+                    _created_at = datetime.fromisoformat(_created_at.replace("Z", "+00:00"))
+                invite_code_data = {
                     "code": result["code"],
                     "description": result.get("description"),
                     "is_used": True,
                     "created_by": str(result["created_by"]),
-                    "used_by": str(used_by),
-                    "created_at": result.get("created_at"),
+                    "used_by": str(used_by) if used_by else None,
+                    "created_at": _created_at,
                     "used_at": current_time,
                 }

Also applies to: 41-48

todo/repositories/user_repository.py (1)

1-12: Use a module-level logger for dual-write warnings

Avoid inline imports; define once and reuse.

 from datetime import datetime, timezone
 from typing import Optional, List
 from pymongo.collection import ReturnDocument
 from pymongo import ASCENDING
+import logging
+logger = logging.getLogger(__name__)
@@
-            if not dual_write_success:
-                import logging
-
-                logger = logging.getLogger(__name__)
-                logger.warning(f"Failed to sync user {user_model.id} to Postgres")
+            if not dual_write_success:
+                logger.warning(f"Failed to sync user {user_model.id} to Postgres")

Also applies to: 87-92